package org.gap.dao;

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.gap.domain.Pays;

import org.skyway.spring.util.dao.AbstractJpaDao;

import org.springframework.dao.DataAccessException;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

/**
 * DAO to manage Pays entities.
 * 
 */
@Repository("PaysDAO")
@Transactional
public class PaysDAOImpl extends AbstractJpaDao<Pays> implements PaysDAO {

	/**
	 * Set of entity classes managed by this DAO.  Typically a DAO manages a single entity.
	 *
	 */
	private final static Set<Class<?>> dataTypes = new HashSet<Class<?>>(Arrays.asList(new Class<?>[] { Pays.class }));

	/**
	 * EntityManager injected by Spring for persistence unit 
	 *
	 */
	@PersistenceContext(unitName = "")
	private EntityManager entityManager;

	/**
	 * Instantiates a new PaysDAOImpl
	 *
	 */
	public PaysDAOImpl() {
		super();
	}

	/**
	 * Get the entity manager that manages persistence unit 
	 *
	 */
	public EntityManager getEntityManager() {
		return entityManager;
	}

	/**
	 * Returns the set of entity classes managed by this DAO.
	 *
	 */
	public Set<Class<?>> getTypes() {
		return dataTypes;
	}

	/**
	 * JPQL Query - findPaysByPrimaryKey
	 *
	 */
	@Transactional
	public Pays findPaysByPrimaryKey(String pppPays) throws DataAccessException {

		return findPaysByPrimaryKey(pppPays, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPrimaryKey
	 *
	 */

	@Transactional
	public Pays findPaysByPrimaryKey(String pppPays, int startResult, int maxRows) throws DataAccessException {
		try {
			return executeQueryByNameSingleResult("findPaysByPrimaryKey", pppPays);
		} catch (NoResultException nre) {
			return null;
		}
	}

	/**
	 * JPQL Query - findPaysByPppMasqueGuichetContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueGuichetContaining(String pppMasqueGuichet) throws DataAccessException {

		return findPaysByPppMasqueGuichetContaining(pppMasqueGuichet, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueGuichetContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueGuichetContaining(String pppMasqueGuichet, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueGuichetContaining", startResult, maxRows, pppMasqueGuichet);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueEtablissementContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueEtablissementContaining(String pppMasqueEtablissement) throws DataAccessException {

		return findPaysByPppMasqueEtablissementContaining(pppMasqueEtablissement, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueEtablissementContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueEtablissementContaining(String pppMasqueEtablissement, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueEtablissementContaining", startResult, maxRows, pppMasqueEtablissement);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findAllPayss
	 *
	 */
	@Transactional
	public Set<Pays> findAllPayss() throws DataAccessException {

		return findAllPayss(-1, -1);
	}

	/**
	 * JPQL Query - findAllPayss
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findAllPayss(int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findAllPayss", startResult, maxRows);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppPaysContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppPaysContaining(String pppPays) throws DataAccessException {

		return findPaysByPppPaysContaining(pppPays, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppPaysContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppPaysContaining(String pppPays, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppPaysContaining", startResult, maxRows, pppPays);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCodePostal
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueCodePostal(String pppMasqueCodePostal) throws DataAccessException {

		return findPaysByPppMasqueCodePostal(pppMasqueCodePostal, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCodePostal
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueCodePostal(String pppMasqueCodePostal, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueCodePostal", startResult, maxRows, pppMasqueCodePostal);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppNInsee
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppNInsee(String pppNInsee) throws DataAccessException {

		return findPaysByPppNInsee(pppNInsee, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppNInsee
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppNInsee(String pppNInsee, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppNInsee", startResult, maxRows, pppNInsee);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppLibelleRecherche
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppLibelleRecherche(String pppLibelleRecherche) throws DataAccessException {

		return findPaysByPppLibelleRecherche(pppLibelleRecherche, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppLibelleRecherche
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppLibelleRecherche(String pppLibelleRecherche, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppLibelleRecherche", startResult, maxRows, pppLibelleRecherche);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppEtiquetteRibContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppEtiquetteRibContaining(String pppEtiquetteRib) throws DataAccessException {

		return findPaysByPppEtiquetteRibContaining(pppEtiquetteRib, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppEtiquetteRibContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppEtiquetteRibContaining(String pppEtiquetteRib, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppEtiquetteRibContaining", startResult, maxRows, pppEtiquetteRib);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppLibelleContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppLibelleContaining(String pppLibelle) throws DataAccessException {

		return findPaysByPppLibelleContaining(pppLibelle, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppLibelleContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppLibelleContaining(String pppLibelle, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppLibelleContaining", startResult, maxRows, pppLibelle);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppLibelleRechercheContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppLibelleRechercheContaining(String pppLibelleRecherche) throws DataAccessException {

		return findPaysByPppLibelleRechercheContaining(pppLibelleRecherche, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppLibelleRechercheContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppLibelleRechercheContaining(String pppLibelleRecherche, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppLibelleRechercheContaining", startResult, maxRows, pppLibelleRecherche);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppCe
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppCe(Boolean pppCe) throws DataAccessException {

		return findPaysByPppCe(pppCe, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppCe
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppCe(Boolean pppCe, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppCe", startResult, maxRows, pppCe);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppCpModifiable
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppCpModifiable(Boolean pppCpModifiable) throws DataAccessException {

		return findPaysByPppCpModifiable(pppCpModifiable, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppCpModifiable
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppCpModifiable(Boolean pppCpModifiable, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppCpModifiable", startResult, maxRows, pppCpModifiable);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppPrefixeInternational
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppPrefixeInternational(Integer pppPrefixeInternational) throws DataAccessException {

		return findPaysByPppPrefixeInternational(pppPrefixeInternational, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppPrefixeInternational
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppPrefixeInternational(Integer pppPrefixeInternational, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppPrefixeInternational", startResult, maxRows, pppPrefixeInternational);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppPays
	 *
	 */
	@Transactional
	public Pays findPaysByPppPays(String pppPays) throws DataAccessException {

		return findPaysByPppPays(pppPays, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppPays
	 *
	 */

	@Transactional
	public Pays findPaysByPppPays(String pppPays, int startResult, int maxRows) throws DataAccessException {
		try {
			return executeQueryByNameSingleResult("findPaysByPppPays", pppPays);
		} catch (NoResultException nre) {
			return null;
		}
	}

	/**
	 * JPQL Query - findPaysByPppMasquePortableContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasquePortableContaining(String pppMasquePortable) throws DataAccessException {

		return findPaysByPppMasquePortableContaining(pppMasquePortable, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasquePortableContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasquePortableContaining(String pppMasquePortable, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasquePortableContaining", startResult, maxRows, pppMasquePortable);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCompteContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueCompteContaining(String pppMasqueCompte) throws DataAccessException {

		return findPaysByPppMasqueCompteContaining(pppMasqueCompte, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCompteContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueCompteContaining(String pppMasqueCompte, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueCompteContaining", startResult, maxRows, pppMasqueCompte);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueTelephoneContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueTelephoneContaining(String pppMasqueTelephone) throws DataAccessException {

		return findPaysByPppMasqueTelephoneContaining(pppMasqueTelephone, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueTelephoneContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueTelephoneContaining(String pppMasqueTelephone, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueTelephoneContaining", startResult, maxRows, pppMasqueTelephone);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppLibelle
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppLibelle(String pppLibelle) throws DataAccessException {

		return findPaysByPppLibelle(pppLibelle, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppLibelle
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppLibelle(String pppLibelle, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppLibelle", startResult, maxRows, pppLibelle);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCompte
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueCompte(String pppMasqueCompte) throws DataAccessException {

		return findPaysByPppMasqueCompte(pppMasqueCompte, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCompte
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueCompte(String pppMasqueCompte, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueCompte", startResult, maxRows, pppMasqueCompte);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueEtablissement
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueEtablissement(String pppMasqueEtablissement) throws DataAccessException {

		return findPaysByPppMasqueEtablissement(pppMasqueEtablissement, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueEtablissement
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueEtablissement(String pppMasqueEtablissement, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueEtablissement", startResult, maxRows, pppMasqueEtablissement);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueGuichet
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueGuichet(String pppMasqueGuichet) throws DataAccessException {

		return findPaysByPppMasqueGuichet(pppMasqueGuichet, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueGuichet
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueGuichet(String pppMasqueGuichet, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueGuichet", startResult, maxRows, pppMasqueGuichet);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCle
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueCle(String pppMasqueCle) throws DataAccessException {

		return findPaysByPppMasqueCle(pppMasqueCle, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCle
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueCle(String pppMasqueCle, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueCle", startResult, maxRows, pppMasqueCle);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasquePortable
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasquePortable(String pppMasquePortable) throws DataAccessException {

		return findPaysByPppMasquePortable(pppMasquePortable, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasquePortable
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasquePortable(String pppMasquePortable, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasquePortable", startResult, maxRows, pppMasquePortable);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppNInseeContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppNInseeContaining(String pppNInsee) throws DataAccessException {

		return findPaysByPppNInseeContaining(pppNInsee, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppNInseeContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppNInseeContaining(String pppNInsee, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppNInseeContaining", startResult, maxRows, pppNInsee);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCleContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueCleContaining(String pppMasqueCle) throws DataAccessException {

		return findPaysByPppMasqueCleContaining(pppMasqueCle, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCleContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueCleContaining(String pppMasqueCle, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueCleContaining", startResult, maxRows, pppMasqueCle);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppOrdreDsIbanContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppOrdreDsIbanContaining(String pppOrdreDsIban) throws DataAccessException {

		return findPaysByPppOrdreDsIbanContaining(pppOrdreDsIban, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppOrdreDsIbanContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppOrdreDsIbanContaining(String pppOrdreDsIban, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppOrdreDsIbanContaining", startResult, maxRows, pppOrdreDsIban);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppEtiquetteRib
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppEtiquetteRib(String pppEtiquetteRib) throws DataAccessException {

		return findPaysByPppEtiquetteRib(pppEtiquetteRib, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppEtiquetteRib
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppEtiquetteRib(String pppEtiquetteRib, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppEtiquetteRib", startResult, maxRows, pppEtiquetteRib);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCodePostalContaining
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueCodePostalContaining(String pppMasqueCodePostal) throws DataAccessException {

		return findPaysByPppMasqueCodePostalContaining(pppMasqueCodePostal, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueCodePostalContaining
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueCodePostalContaining(String pppMasqueCodePostal, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueCodePostalContaining", startResult, maxRows, pppMasqueCodePostal);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppMasqueTelephone
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppMasqueTelephone(String pppMasqueTelephone) throws DataAccessException {

		return findPaysByPppMasqueTelephone(pppMasqueTelephone, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppMasqueTelephone
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppMasqueTelephone(String pppMasqueTelephone, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppMasqueTelephone", startResult, maxRows, pppMasqueTelephone);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * JPQL Query - findPaysByPppOrdreDsIban
	 *
	 */
	@Transactional
	public Set<Pays> findPaysByPppOrdreDsIban(String pppOrdreDsIban) throws DataAccessException {

		return findPaysByPppOrdreDsIban(pppOrdreDsIban, -1, -1);
	}

	/**
	 * JPQL Query - findPaysByPppOrdreDsIban
	 *
	 */

	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Pays> findPaysByPppOrdreDsIban(String pppOrdreDsIban, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findPaysByPppOrdreDsIban", startResult, maxRows, pppOrdreDsIban);
		return new LinkedHashSet<Pays>(query.getResultList());
	}

	/**
	 * Used to determine whether or not to merge the entity or persist the entity when calling Store
	 * @see store
	 * 
	 *
	 */
	public boolean canBeMerged(Pays entity) {
		return true;
	}
}
